/*
  运维工程师采集到某产品线网运行一天产生的日志n条
  现需根据日志时间先后顺序对日志进行排序
  日志时间格式为H:M:S.N
  H表示小时(0~23)
  M表示分钟(0~59)
  S表示秒(0~59)
  N表示毫秒(0~999)
  时间可能并没有补全
  也就是说
  01:01:01.001也可能表示为1:1:1.1

  输入描述
     第一行输入一个整数n表示日志条数
     1<=n<=100000
     接下来n行输入n个时间

   输出描述
     按时间升序排序之后的时间
     如果有两个时间表示的时间相同
     则保持输入顺序

   示例：
     输入：
      2
      01:41:8.9
      1:1:09.211
     输出
       1:1:09.211
       01:41:8.9
   示例
      输入
       3
       23:41:08.023
       1:1:09.211
       08:01:22.0
      输出
        1:1:09.211
        08:01:22.0
        23:41:08.023

    示例
      输入
        2
        22:41:08.023
        22:41:08.23
      输出
        22:41:08.023
        22:41:08.23
      时间相同保持输入顺序
       */

const test = (input) => {
    let inputArr = input.split('\n').map(t => t.trim())
    console.log(inputArr)
    let [n, ...times] = inputArr
    console.log(n, times)
    let sortFn = (a, b, fields) => {
        if (Array.isArray(fields) && fields.length) {
            let field = fields[0]
            let aVal = parseInt(a[field]), bVal = parseInt(b[field])
            if (aVal > bVal) {
                return 1
            } else if (aVal < bVal) {
                return -1
            } else {
                if (fields.length > 1) {
                    return sortFn(a, b, fields.slice(1))
                }
                return 0
            }
        }
    }
    let reg = /([\d]{1,2}):([\d]{1,2}):([\d]{1,2})\.([\d]{1,3})/


    let seq = times.map(t => {
        // H:M:S.N
        let match = t.match(reg)
        let [time, H, M, S, N] = match
        return {
            time, H, M, S, N
        }
    }).sort((a, b) => sortFn(a, b, ['H', 'M', 'S', 'N']))

    console.log(seq.map(t => t.time).join("\n"))

}
test(`2
    01:41:8.9
    1:1:09.211`)
test(`3
23:41:08.023
1:1:09.211
08:01:22.0`)

test(`2
22:41:08.023
22:41:08.23`)